The Atari Compendium

home *** CD-ROM | disk | FTP | other *** search

/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / othergnu / atari-~1.zoo / atari-groff.diff next >

Wrap

Text File | 1992-05-10 | 35.6 KB | 1,236 lines

diff -rc2N groff-1.05/Makefile groff-1.05.atari/Makefile *** groff-1.05/Makefile Sat May 9 15:42:02 1992 --- groff-1.05.atari/Makefile Sat May 9 22:48:08 1992 *************** *** 1,5 **** #Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc. # Written by James Clark (jjc@jclark.com) - # #This file is part of groff. # --- 1,4 ---- *************** *** 123,130 **** # Uncomment the next line if you have vfork(). ! D2=#-DHAVE_VFORK # Uncomment the next line if you have sys_siglist[]. ! D3=#-DHAVE_SYS_SIGLIST # Uncomment the next line if you have the mmap() system call (and you --- 122,129 ---- # Uncomment the next line if you have vfork(). ! D2=-DHAVE_VFORK # Uncomment the next line if you have sys_siglist[]. ! D3=-DHAVE_SYS_SIGLIST # Uncomment the next line if you have the mmap() system call (and you *************** *** 133,137 **** # Uncomment the next line if you have the rename() system call. ! D5=#-DHAVE_RENAME # Uncomment the next line if the argument to localtime() is a long* --- 132,136 ---- # Uncomment the next line if you have the rename() system call. ! D5=-DHAVE_RENAME # Uncomment the next line if the argument to localtime() is a long* *************** *** 141,145 **** # Uncomment the next line if wait is declared by your C++ header files # to take an argument of type union wait *. ! D7=#-DHAVE_UNION_WAIT # Uncoment the next line if your C++ header files declare a type pid_t --- 140,144 ---- # Uncomment the next line if wait is declared by your C++ header files # to take an argument of type union wait *. ! D7=-DHAVE_UNION_WAIT # Uncoment the next line if your C++ header files declare a type pid_t *************** *** 155,159 **** # Uncomment the next line if <sys/wait.h> should not be included # when using wait(). Use this with the libg++ header files. ! D10=-DNO_SYS_WAIT_H # Uncomment the next line if you C++ compiler requires delete [n] rather --- 154,158 ---- # Uncomment the next line if <sys/wait.h> should not be included # when using wait(). Use this with the libg++ header files. ! D10=#-DNO_SYS_WAIT_H # Uncomment the next line if you C++ compiler requires delete [n] rather *************** *** 185,189 **** # MALLOCFLAGS=-DUSG # Use this with SunOS 4.1 and 4.1.1. ! MALLOCFLAGS=-DBSD -DSUNOS_LOCALTIME_BUG # Comment this out if the GNU malloc gives you problems, or if you would --- 184,189 ---- # MALLOCFLAGS=-DUSG # Use this with SunOS 4.1 and 4.1.1. ! #MALLOCFLAGS=-DBSD -DSUNOS_LOCALTIME_BUG ! MALLOCFLAGS=-DBSD # Comment this out if the GNU malloc gives you problems, or if you would *************** *** 211,217 **** # CC is the C++ compiler ! CC=g++ # This is the flag that tells the C++ compiler to treat a .c file as C++. ! C++LANG_FLAG= # I'm told that -fno-inline is needed on a 68030-based Apollo # CC=g++ -fno-inline --- 211,217 ---- # CC is the C++ compiler ! # CC=g++ # This is the flag that tells the C++ compiler to treat a .c file as C++. ! # C++LANG_FLAG= # I'm told that -fno-inline is needed on a 68030-based Apollo # CC=g++ -fno-inline *************** *** 218,223 **** # Use this with gcc/g++ version 2. ! # CC=gcc ! # C++LANG_FLAG=-xc++ # OLDCC is the C compiler. --- 218,223 ---- # Use this with gcc/g++ version 2. ! CC=gcc ! C++LANG_FLAG=-xc++ # OLDCC is the C compiler. *************** *** 225,231 **** PROFILE_FLAG= ! DEBUG_FLAG=-g # With gcc/g++ 2.0 on a sparc, -O works better than -O2. ! OPTIMIZE_FLAG=-O WARNING_FLAGS=#-Wall -Wcast-qual -Wwrite-strings --- 225,232 ---- PROFILE_FLAG= ! DEBUG_FLAG= # With gcc/g++ 2.0 on a sparc, -O works better than -O2. ! #OPTIMIZE_FLAG=-O ! OPTIMIZE_FLAG=-O2 WARNING_FLAGS=#-Wall -Wcast-qual -Wwrite-strings *************** *** 245,253 **** LDFLAGS=$(PROFILE_FLAG) $(DEBUG_FLAG) $(XLDFLAGS) # Libraries needed for linking C++ programs. ! LIBS= # Libraries needed for linking C++ programs that use libm.a. ! MLIBS=$(LIBS) -lm ! AR=ar # Define RANLIB to be empty if you don't have ranlib. --- 246,255 ---- LDFLAGS=$(PROFILE_FLAG) $(DEBUG_FLAG) $(XLDFLAGS) # Libraries needed for linking C++ programs. ! LIBS=-lg++ # Libraries needed for linking C++ programs that use libm.a. ! #MLIBS=$(LIBS) -lm ! MLIBS=$(LIBS) ! AR=gcc-ar # Define RANLIB to be empty if you don't have ranlib. Binary files groff-1.05/gendef and groff-1.05.atari/gendef differ diff -rc2N groff-1.05/groff.c groff-1.05.atari/groff.c *** groff-1.05/groff.c Wed Oct 30 12:12:48 1991 --- groff-1.05.atari/groff.c Sat May 9 22:24:26 1992 *************** *** 45,50 **** #else typedef int PID_T; ! #endif ! #ifdef HAVE_UNION_WAIT typedef union wait WAIT_STATUS_T; --- 45,49 ---- #else typedef int PID_T; ! #endif // HAVE_PID_T #ifdef HAVE_UNION_WAIT typedef union wait WAIT_STATUS_T; diff -rc2N groff-1.05/lib/Makefile groff-1.05.atari/lib/Makefile *** groff-1.05/lib/Makefile Thu Aug 22 12:32:00 1991 --- groff-1.05.atari/lib/Makefile Sat May 9 20:24:40 1992 *************** *** 34,38 **** ptable.o font.o fontfile.o nametoindex.o filename.o lineno.o \ progname.o lf.o change_lf.o version.o tmpfile.o \ ! $(FMOD) $(STRTOL) $(GETCWD) SOURCES=new.c itoa.c strerror.c error.c errarg.c fatal.c prime.c \ strsave.c matherr.c fmod.c assert.c iftoa.c tmpfile.c getcwd.c \ --- 34,39 ---- ptable.o font.o fontfile.o nametoindex.o filename.o lineno.o \ progname.o lf.o change_lf.o version.o tmpfile.o \ ! $(FMOD) $(STRTOL) $(GETCWD) getopt.o getopt1.o ! SOURCES=new.c itoa.c strerror.c error.c errarg.c fatal.c prime.c \ strsave.c matherr.c fmod.c assert.c iftoa.c tmpfile.c getcwd.c \ *************** *** 39,42 **** --- 40,44 ---- string.c cset.c cmap.c ptable.c font.c fontfile.c nametoindex.c \ filename.c lineno.c progname.c lf.c change_lf.c version.c \ + getopt.c getopt1.o getopt.h \ assert.h cset.h cmap.h errarg.h error.h font.h getpagesize.h \ lib.h ptable.h stringclass.h *************** *** 55,58 **** --- 57,66 ---- @echo const char \*version_string = \"`cat ../VERSION`\"\; >$@ + getopt.o: getopt.c getopt.h + $(OLDCC) $(OLDCFLAGS) -c getopt.c + + getopt1.o: getopt1.c getopt.h + $(OLDCC) $(OLDCFLAGS) -c getopt1.c + malloc.o: malloc.c getpagesize.h $(OLDCC) $(OLDCFLAGS) $(MALLOCFLAGS) -c malloc.c *************** *** 84,88 **** tmpfile.o: lib.h errarg.h error.h ! fontpath.h: FORCE @$(SHELL) ../gendef $@ "FONTPATH=\"$(FONTPATH)\"" --- 92,98 ---- tmpfile.o: lib.h errarg.h error.h ! #fontpath.h: FORCE ! # @$(SHELL) ../gendef $@ "FONTPATH=\"$(FONTPATH)\"" ! fontpath.h: @$(SHELL) ../gendef $@ "FONTPATH=\"$(FONTPATH)\"" diff -rc2N groff-1.05/lib/getopt.c groff-1.05.atari/lib/getopt.c *** groff-1.05/lib/getopt.c --- groff-1.05.atari/lib/getopt.c Sat May 9 19:25:24 1992 *************** *** 0 **** --- 1,595 ---- + /* Getopt for GNU. + Copyright (C) 1987, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + #ifdef __STDC__ + #define CONST const + #else + #define CONST + #endif + + /* This version of `getopt' appears to the caller like standard Unix `getopt' + but it behaves differently for the user, since it allows the user + to intersperse the options with the other arguments. + + As `getopt' works, it permutes the elements of `argv' so that, + when it is done, all the options precede everything else. Thus + all application programs are extended to handle flexible argument order. + + Setting the environment variable _POSIX_OPTION_ORDER disables permutation. + Then the behavior is completely standard. + + GNU application programs can use a third alternative mode in which + they can distinguish the relative order of options and other arguments. */ + + #include <stdio.h> + + /* If compiled with GNU C, use the built-in alloca */ + #ifdef __GNUC__ + #define alloca __builtin_alloca + #else /* not __GNUC__ */ + #ifdef sparc + #include <alloca.h> + #else + char *alloca (); + #endif + #endif /* not __GNUC__ */ + + #if defined(STDC_HEADERS) || defined(__GNU_LIBRARY__) + #include <stdlib.h> + #include <string.h> + #define bcopy(s, d, n) memcpy ((d), (s), (n)) + #define index strchr + #else + + #ifdef USG + #include <string.h> + #define bcopy(s, d, n) memcpy ((d), (s), (n)) + #define index strchr + #else + #ifdef VMS + #include <string.h> + #else + #include <strings.h> + #endif + void bcopy (); + #endif + + char *getenv (); + char *malloc (); + #endif + + /* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + + char *optarg = 0; + + /* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns EOF, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + + int optind = 0; + + /* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + + static char *nextchar; + + /* Callers store zero here to inhibit the error message + for unrecognized options. */ + + int opterr = 1; + + /* Describe how to deal with options that follow non-option ARGV-elements. + + If the caller did not specify anything, + the default is REQUIRE_ORDER if the environment variable + _POSIX_OPTION_ORDER is defined, PERMUTE otherwise. + + REQUIRE_ORDER means don't recognize them as options; + stop option processing when the first non-option is seen. + This is what Unix does. + This mode of operation is selected by either setting the environment + variable _POSIX_OPTION_ORDER, or using `+' as the first character + of the list of option characters. + + PERMUTE is the default. We permute the contents of ARGV as we scan, + so that eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written to + expect this. + + RETURN_IN_ORDER is an option available to programs that were written + to expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. + Using `-' as the first character of the list of option characters + selects this mode of operation. + + The special argument `--' forces an end of option-scanning regardless + of the value of `ordering'. In the case of RETURN_IN_ORDER, only + `--' can cause `getopt' to return EOF with `optind' != ARGC. */ + + static enum + { + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER + } ordering; + + /* Describe the long-named options requested by the application. + _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an + element containing a name which is zero. + The field `has_arg' is 1 if the option takes an argument, + 2 if it takes an optional argument. */ + + struct option + { + char *name; + int has_arg; + int *flag; + int val; + }; + + CONST struct option *_getopt_long_options; + + int _getopt_long_only = 0; + + /* Index in _GETOPT_LONG_OPTIONS of the long-named option actually found. + Only valid when a long-named option was found. */ + + int option_index; + + /* Handle permutation of arguments. */ + + /* Describe the part of ARGV that contains non-options that have + been skipped. `first_nonopt' is the index in ARGV of the first of them; + `last_nonopt' is the index after the last of them. */ + + static int first_nonopt; + static int last_nonopt; + + /* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,optind), which contains all + the options processed since those non-options were skipped. + + `first_nonopt' and `last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + + static void + exchange (argv) + char **argv; + { + int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *); + char **temp = (char **) alloca (nonopts_size); + + /* Interchange the two blocks of data in ARGV. */ + + bcopy (&argv[first_nonopt], temp, nonopts_size); + bcopy (&argv[last_nonopt], &argv[first_nonopt], + (optind - last_nonopt) * sizeof (char *)); + bcopy (temp, &argv[first_nonopt + optind - last_nonopt], nonopts_size); + + /* Update records for the slots the non-options now occupy. */ + + first_nonopt += (optind - last_nonopt); + last_nonopt = optind; + } + + /* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If `getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If `getopt' finds another option character, it returns that character, + updating `optind' and `nextchar' so that the next call to `getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, `getopt' returns `EOF'. + Then `optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set `opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in `optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in `optarg', otherwise `optarg' is set to zero. + + If OPTSTRING starts with `-' or `+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with `+' instead of `-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a `=', or else the in next ARGV-element. + When `getopt' finds a long-named option, it returns 0 if that option's + `flag' field is nonzero, the value of the option's `val' field + otherwise. */ + + int + getopt (argc, argv, optstring) + int argc; + char **argv; + CONST char *optstring; + { + optarg = 0; + + /* Initialize the internal data when the first call is made. + Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + + if (optind == 0) + { + first_nonopt = last_nonopt = optind = 1; + + nextchar = 0; + + /* Determine how to handle the ordering of options and nonoptions. */ + + if (optstring[0] == '-') + { + ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + ordering = REQUIRE_ORDER; + ++optstring; + } + else if (getenv ("_POSIX_OPTION_ORDER") != 0) + ordering = REQUIRE_ORDER; + else + ordering = PERMUTE; + } + + if (nextchar == 0 || *nextchar == 0) + { + if (ordering == PERMUTE) + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange (argv); + else if (last_nonopt != optind) + first_nonopt = optind; + + /* Now skip any additional non-options + and extend the range of non-options previously skipped. */ + + while (optind < argc + && (argv[optind][0] != '-' + || argv[optind][1] == 0) + && (_getopt_long_options == 0 + || argv[optind][0] != '+' + || argv[optind][1] == 0)) + optind++; + last_nonopt = optind; + } + + /* Special ARGV-element `--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if (optind != argc && !strcmp (argv[optind], "--")) + { + optind++; + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange (argv); + else if (first_nonopt == last_nonopt) + first_nonopt = optind; + last_nonopt = argc; + + optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if (optind == argc) + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (first_nonopt != last_nonopt) + optind = first_nonopt; + return EOF; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if ((argv[optind][0] != '-' || argv[optind][1] == 0) + && (_getopt_long_options == 0 + || argv[optind][0] != '+' || argv[optind][1] == 0)) + { + if (ordering == REQUIRE_ORDER) + return EOF; + optarg = argv[optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Start decoding its characters. */ + + nextchar = argv[optind] + 1; + } + + if (_getopt_long_options != 0 + && (argv[optind][0] == '+' + || (_getopt_long_only && argv[optind][0] == '-')) + ) + { + CONST struct option *p; + char *s = nextchar; + int exact = 0; + int ambig = 0; + CONST struct option *pfound = 0; + int indfound; + + while (*s && *s != '=') + s++; + + /* Test all options for either exact match or abbreviated matches. */ + for (p = _getopt_long_options, option_index = 0; p->name; + p++, option_index++) + if (!strncmp (p->name, nextchar, s - nextchar)) + { + if (s - nextchar == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == 0) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second nonexact match found. */ + ambig = 1; + } + + if (ambig && !exact) + { + fprintf (stderr, "%s: option `%s' is ambiguous\n", + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + return '?'; + } + + if (pfound != 0) + { + option_index = indfound; + optind++; + if (*s) + { + if (pfound->has_arg > 0) + optarg = s + 1; + else + { + fprintf (stderr, + "%s: option `%c%s' doesn't allow an argument\n", + argv[0], argv[optind - 1][0], pfound->name); + nextchar += strlen (nextchar); + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + fprintf (stderr, "%s: option `%s' requires an argument\n", + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + return '?'; + } + } + nextchar += strlen (nextchar); + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + /* Can't find it as a long option. If this is getopt_long_only, + and the option starts with '-' and is a valid short + option, then interpret it as a short option. Otherwise it's + an error. */ + if (_getopt_long_only == 0 || argv[optind][0] == '+' || + index (optstring, *nextchar) == 0) + { + if (opterr != 0) + fprintf (stderr, "%s: unrecognized option `%c%s'\n", + argv[0], argv[optind][0], nextchar); + nextchar += strlen (nextchar); + optind++; + return '?'; + } + } + + /* Look at and handle the next option-character. */ + + { + char c = *nextchar++; + char *temp = index (optstring, c); + + /* Increment `optind' when we start to process its last character. */ + if (*nextchar == 0) + optind++; + + if (temp == 0 || c == ':') + { + if (opterr != 0) + { + if (c < 040 || c >= 0177) + fprintf (stderr, "%s: unrecognized option, character code 0%o\n", + argv[0], c); + else + fprintf (stderr, "%s: unrecognized option `-%c'\n", + argv[0], c); + } + return '?'; + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*nextchar != 0) + { + optarg = nextchar; + optind++; + } + else + optarg = 0; + nextchar = 0; + } + else + { + /* This is an option that requires an argument. */ + if (*nextchar != 0) + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr != 0) + fprintf (stderr, "%s: option `-%c' requires an argument\n", + argv[0], c); + c = '?'; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + nextchar = 0; + } + } + return c; + } + } + + #ifdef TEST + + /* Compile with -DTEST to make an executable for use in testing + the above definition of `getopt'. */ + + int + main (argc, argv) + int argc; + char **argv; + { + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + + c = getopt (argc, argv, "abc:d:0123456789"); + if (c == EOF) + break; + + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); + } + + #endif /* TEST */ diff -rc2N groff-1.05/lib/getopt.h groff-1.05.atari/lib/getopt.h *** groff-1.05/lib/getopt.h --- groff-1.05.atari/lib/getopt.h Sat May 9 20:42:54 1992 *************** *** 0 **** --- 1,121 ---- + /* declarations for getopt -- command-line argument scanning subroutine + Copyright 1989-1991 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this proggram; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + /* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + + #ifndef __GETOPT_H + #define __GETOPT_H + + #ifdef __cplusplus + extern "C" { + #endif + + extern char *optarg; + + /* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns EOF, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + + extern int optind; + + /* Callers store zero here to inhibit the error message `getopt' prints + for unrecognized options. */ + + extern int opterr; + + /* Describe the long-named options requested by the application. + _GETOPT_LONG_OPTIONS is a vector of `struct option' terminated by an + element containing a name which is zero. + + The field `has_arg' is: + 0 if the option does not take an argument, + 1 if the option requires an argument, + 2 if the option takes an optional argument. + + The type getopt_long_has_arg defines these values below. + + If the field `flag' is nonzero, it points to a variable that is set + to the value given in the field `val' when the option is found, but + left unchanged if the option is not found. + + To have a long-named option do something other than set an `int' to + a compiled-in constant, such as set a value from `optarg', set the + option's `flag' field to zero and its `val' field to a nonzero + value (the equivalent single-letter option character, if there is + one). For long options that have a zero `flag' field, `getopt' + returns the contents of the `val' field. */ + + enum getopt_long_has_arg { + GETOPT_NO_ARG = 0, + GETOPT_REQ_ARG = 1, + GETOPT_OPT_ARG = 2 + }; + + struct option + { + char *name; + int has_arg; + int *flag; + int val; + }; + + #ifdef __STDC__ + extern const struct option *_getopt_long_options; + #else + extern struct option *_getopt_long_options; + #endif + + /* If nonzero, '-' can introduce long-named options. + Set by getopt_long_only. */ + + extern int _getopt_long_only; + + /* The index in GETOPT_LONG_OPTIONS of the long-named option found. + Only valid when a long-named option has been found by the most + recent call to `getopt'. */ + + extern int option_index; + + #ifdef __STDC__ + int getopt (int argc, char **argv, const char *shortopts); + int getopt_long (int argc, char **argv, const char *shortopts, + const struct option *longopts, int *longind); + int getopt_long_only (int argc, char **argv, const char *shortopts, + const struct option *longopts, int *longind); + void envopt(int *pargc, char ***pargv, char *optstr); + #else + int getopt (); + int getopt_long (); + int getopt_long_only (); + void envopt(); + #endif + #ifdef __cplusplus + } + #endif + #endif /* __GETOPT_H */ diff -rc2N groff-1.05/lib/getopt1.c groff-1.05.atari/lib/getopt1.c *** groff-1.05/lib/getopt1.c --- groff-1.05.atari/lib/getopt1.c Sat May 9 19:25:26 1992 *************** *** 0 **** --- 1,160 ---- + /* Getopt for GNU. + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + #include "getopt.h" + + #ifdef __STDC__ + #define CONST const + #else + #define CONST + #endif + + #if !defined (NULL) + #define NULL 0 + #endif + + int + getopt_long (argc, argv, options, long_options, opt_index) + int argc; + char **argv; + CONST char *options; + CONST struct option *long_options; + int *opt_index; + { + int val; + + _getopt_long_options = long_options; + val = getopt (argc, argv, options); + if (val == 0 && opt_index != NULL) + *opt_index = option_index; + return val; + } + + /* Like getopt_long, but '-' as well as '+' can indicate a long option. + If an option that starts with '-' doesn't match a long option, + but does match a short option, it is parsed as a short option + instead. */ + + int + getopt_long_only (argc, argv, options, long_options, opt_index) + int argc; + char **argv; + CONST char *options; + CONST struct option *long_options; + int *opt_index; + { + int val; + + _getopt_long_options = long_options; + _getopt_long_only = 1; + val = getopt (argc, argv, options); + if (val == 0 && opt_index != NULL) + *opt_index = option_index; + return val; + } + + + #ifdef TEST + + #include <stdio.h> + + int + main (argc, argv) + int argc; + char **argv; + { + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + char *name = '\0'; + int option_index = 0; + static struct option long_options[] = + { + {"add", 1, 0, 0}, + {"append", 0, 0, 0}, + {"delete", 1, 0, 0}, + {"verbose", 0, 0, 0}, + {"create", 0, 0, 0}, + {"file", 1, 0, 0}, + {0, 0, 0, 0} + }; + + c = getopt_long (argc, argv, "abc:d:0123456789", + long_options, &option_index); + if (c == EOF) + break; + + switch (c) + { + case 0: + printf ("option %s", (long_options[option_index]).name); + if (optarg) + printf (" with arg %s", optarg); + printf ("\n"); + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); + } + + #endif /* TEST */ diff -rc2N groff-1.05/lib/getpagesize.h groff-1.05.atari/lib/getpagesize.h *** groff-1.05/lib/getpagesize.h Wed Feb 21 01:35:42 1990 --- groff-1.05.atari/lib/getpagesize.h Sat May 9 19:06:48 1992 *************** *** 1,2 **** --- 1,5 ---- + #ifdef atarist + #define getpagesize() 4096 + #else #ifdef BSD #ifndef BSD4_1 *************** *** 21,25 **** #endif /* no NBPG */ #endif /* no EXEC_PAGESIZE */ - #endif /* not HAVE_GETPAGESIZE */ ! --- 24,27 ---- #endif /* no NBPG */ #endif /* no EXEC_PAGESIZE */ #endif /* not HAVE_GETPAGESIZE */ ! #endif /* atarist */ diff -rc2N groff-1.05/lib/lib.h groff-1.05.atari/lib/lib.h *** groff-1.05/lib/lib.h Sat May 9 15:43:04 1992 --- groff-1.05.atari/lib/lib.h Sat May 9 20:26:20 1992 *************** *** 32,35 **** --- 32,38 ---- int is_prime(unsigned); #include <stdio.h> + #ifdef atarist + #include "getopt.h" + #endif FILE *xtmpfile(); diff -rc2N groff-1.05/lib/strerror.c groff-1.05.atari/lib/strerror.c *** groff-1.05/lib/strerror.c Sat Jan 19 10:59:24 1991 --- groff-1.05.atari/lib/strerror.c Sat May 9 19:04:24 1992 *************** *** 1,2 **** --- 1,3 ---- + #ifndef atarist /* Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc. Written by James Clark (jjc@jclark.uucp) *************** *** 34,35 **** --- 35,37 ---- } } + #endif atarist diff -rc2N groff-1.05/pic/mkpictab groff-1.05.atari/pic/mkpictab *** groff-1.05/pic/mkpictab --- groff-1.05.atari/pic/mkpictab Sat May 9 23:21:28 1992 *************** *** 0 **** --- 1 ---- + gcc -c -I../lib -xc++ -O2 -DHAVE_VFORK -DHAVE_SYS_SIGLIST -DHAVE_RENAME -DHAVE_UNION_WAIT -DWAIT_COREDUMP_0200 pic.tab.c diff -rc2N groff-1.05/pic/pic.y groff-1.05.atari/pic/pic.y *** groff-1.05/pic/pic.y Sat May 9 15:45:24 1992 --- groff-1.05.atari/pic/pic.y Sat May 9 19:15:56 1992 *************** *** 31,34 **** --- 31,35 ---- extern void do_lookahead(); + #if !defined(_M68881) && !defined(__M68881) extern "C" { double fmod(double, double); *************** *** 35,38 **** --- 36,40 ---- int rand(); } + #endif /* Maximum number of characters produced by printf("%g") */ diff -rc2N groff-1.05/ps/Makefile groff-1.05.atari/ps/Makefile *** groff-1.05/ps/Makefile Sat May 9 15:45:26 1992 --- groff-1.05.atari/ps/Makefile Sat May 9 21:33:28 1992 *************** *** 55,59 **** ../lib/stringclass.h ../lib/cset.h ! broken.h: FORCE @$(SHELL) ../gendef $@ "BROKEN_SPOOLER_FLAGS=$(BROKEN_SPOOLER_FLAGS)" --- 55,62 ---- ../lib/stringclass.h ../lib/cset.h ! #broken.h: FORCE ! # @$(SHELL) ../gendef $@ "BROKEN_SPOOLER_FLAGS=$(BROKEN_SPOOLER_FLAGS)" ! ! broken.h: @$(SHELL) ../gendef $@ "BROKEN_SPOOLER_FLAGS=$(BROKEN_SPOOLER_FLAGS)" diff -rc2N groff-1.05/refer/indxbib.c groff-1.05.atari/refer/indxbib.c *** groff-1.05/refer/indxbib.c Sat May 9 15:45:50 1992 --- groff-1.05.atari/refer/indxbib.c Sat May 9 21:25:54 1992 *************** *** 206,212 **** --- 206,218 ---- if (!mktemp(temp_index_file) || !temp_index_file[0]) fatal("cannot create file name for temporary file"); + #ifndef atarist signal(SIGHUP, fatal_signal); signal(SIGINT, fatal_signal); signal(SIGTERM, fatal_signal); + #else + signal(SIGHUP, (__Sigfunc) fatal_signal); + signal(SIGINT, (__Sigfunc) fatal_signal); + signal(SIGTERM,(__Sigfunc) fatal_signal); + #endif int fd = creat(temp_index_file, 0444); if (fd < 0)